{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "af7a981c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "g:\\anaconda3\\envs\\torch\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch\n",
    "import os\n",
    "import sys\n",
    "import json\n",
    "import torch.optim as optim\n",
    "from torchvision import transforms, datasets\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "94bd36e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BasicBlock(nn.Module):\n",
    "    expansion = 1\n",
    "\n",
    "    def __init__(self, in_channel, out_channel, stride=1, downsample=None, **kwargs):\n",
    "        super(BasicBlock, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,\n",
    "                               kernel_size=3, stride=stride, padding=1, bias=False)\n",
    "        self.bn1 = nn.BatchNorm2d(out_channel)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,\n",
    "                               kernel_size=3, stride=1, padding=1, bias=False)\n",
    "        self.bn2 = nn.BatchNorm2d(out_channel)\n",
    "        self.downsample = downsample\n",
    "\n",
    "    def forward(self, x):\n",
    "        identity = x\n",
    "        if self.downsample is not None:\n",
    "            identity = self.downsample(x)\n",
    "\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "\n",
    "        out += identity\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "08090c14",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bottleneck(nn.Module):\n",
    "    \"\"\"\n",
    "    注意：原论文中，在虚线残差结构的主分支上，第一个1x1卷积层的步距是2，第二个3x3卷积层步距是1。\n",
    "    但在pytorch官方实现过程中是第一个1x1卷积层的步距是1，第二个3x3卷积层步距是2，\n",
    "    这么做的好处是能够在top1上提升大概0.5%的准确率。\n",
    "    可参考Resnet v1.5 https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch\n",
    "    \"\"\"\n",
    "    expansion = 4\n",
    "\n",
    "    def __init__(self, in_channel, out_channel, stride=1, downsample=None,\n",
    "                 groups=1, width_per_group=64):\n",
    "        super(Bottleneck, self).__init__()\n",
    "\n",
    "        width = int(out_channel * (width_per_group / 64.)) * groups\n",
    "\n",
    "        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=width,\n",
    "                               kernel_size=1, stride=1, bias=False)  # squeeze channels\n",
    "        self.bn1 = nn.BatchNorm2d(width)\n",
    "        # -----------------------------------------\n",
    "        self.conv2 = nn.Conv2d(in_channels=width, out_channels=width, groups=groups,\n",
    "                               kernel_size=3, stride=stride, bias=False, padding=1)\n",
    "        self.bn2 = nn.BatchNorm2d(width)\n",
    "        # -----------------------------------------\n",
    "        self.conv3 = nn.Conv2d(in_channels=width, out_channels=out_channel*self.expansion,\n",
    "                               kernel_size=1, stride=1, bias=False)  # unsqueeze channels\n",
    "        self.bn3 = nn.BatchNorm2d(out_channel*self.expansion)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.downsample = downsample\n",
    "\n",
    "    def forward(self, x):\n",
    "        identity = x\n",
    "        if self.downsample is not None:\n",
    "            identity = self.downsample(x)\n",
    "\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv3(out)\n",
    "        out = self.bn3(out)\n",
    "\n",
    "        out += identity\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8f063e03",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResNet(nn.Module):\n",
    "\n",
    "    def __init__(self,\n",
    "                 block,\n",
    "                 blocks_num,\n",
    "                 num_classes=1000,\n",
    "                 include_top=True,\n",
    "                 groups=1,\n",
    "                 width_per_group=64):\n",
    "        super(ResNet, self).__init__()\n",
    "        self.include_top = include_top\n",
    "        self.in_channel = 64\n",
    "\n",
    "        self.groups = groups\n",
    "        self.width_per_group = width_per_group\n",
    "\n",
    "        self.conv1 = nn.Conv2d(3, self.in_channel, kernel_size=7, stride=2,\n",
    "                               padding=3, bias=False)\n",
    "        self.bn1 = nn.BatchNorm2d(self.in_channel)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
    "        self.layer1 = self._make_layer(block, 64, blocks_num[0])\n",
    "        self.layer2 = self._make_layer(block, 128, blocks_num[1], stride=2)\n",
    "        self.layer3 = self._make_layer(block, 256, blocks_num[2], stride=2)\n",
    "        self.layer4 = self._make_layer(block, 512, blocks_num[3], stride=2)\n",
    "        if self.include_top:\n",
    "            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # output size = (1, 1)\n",
    "            self.fc = nn.Linear(512 * block.expansion, num_classes)\n",
    "\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n",
    "\n",
    "    def _make_layer(self, block, channel, block_num, stride=1):\n",
    "        downsample = None\n",
    "        if stride != 1 or self.in_channel != channel * block.expansion:\n",
    "            downsample = nn.Sequential(\n",
    "                nn.Conv2d(self.in_channel, channel * block.expansion, kernel_size=1, stride=stride, bias=False),\n",
    "                nn.BatchNorm2d(channel * block.expansion))\n",
    "\n",
    "        layers = []\n",
    "        layers.append(block(self.in_channel,\n",
    "                            channel,\n",
    "                            downsample=downsample,\n",
    "                            stride=stride,\n",
    "                            groups=self.groups,\n",
    "                            width_per_group=self.width_per_group))\n",
    "        self.in_channel = channel * block.expansion\n",
    "\n",
    "        for _ in range(1, block_num):\n",
    "            layers.append(block(self.in_channel,\n",
    "                                channel,\n",
    "                                groups=self.groups,\n",
    "                                width_per_group=self.width_per_group))\n",
    "\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.bn1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool(x)\n",
    "\n",
    "        x = self.layer1(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "\n",
    "        if self.include_top:\n",
    "            x = self.avgpool(x)\n",
    "            x = torch.flatten(x, 1)\n",
    "            x = self.fc(x)\n",
    "\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1127307b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def resnet34(num_classes=1000, include_top=True):\n",
    "    # https://download.pytorch.org/models/resnet34-333f7ec4.pth\n",
    "    return ResNet(BasicBlock, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)\n",
    "\n",
    "\n",
    "def resnet50(num_classes=1000, include_top=True):\n",
    "    # https://download.pytorch.org/models/resnet50-19c8e357.pth\n",
    "    return ResNet(Bottleneck, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)\n",
    "\n",
    "\n",
    "def resnet101(num_classes=1000, include_top=True):\n",
    "    # https://download.pytorch.org/models/resnet101-5d3b4d8f.pth\n",
    "    return ResNet(Bottleneck, [3, 4, 23, 3], num_classes=num_classes, include_top=include_top)\n",
    "\n",
    "\n",
    "def resnext50_32x4d(num_classes=1000, include_top=True):\n",
    "    # https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth\n",
    "    groups = 32\n",
    "    width_per_group = 4\n",
    "    return ResNet(Bottleneck, [3, 4, 6, 3],\n",
    "                  num_classes=num_classes,\n",
    "                  include_top=include_top,\n",
    "                  groups=groups,\n",
    "                  width_per_group=width_per_group)\n",
    "\n",
    "\n",
    "def resnext101_32x8d(num_classes=1000, include_top=True):\n",
    "    # https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth\n",
    "    groups = 32\n",
    "    width_per_group = 8\n",
    "    return ResNet(Bottleneck, [3, 4, 23, 3],\n",
    "                  num_classes=num_classes,\n",
    "                  include_top=include_top,\n",
    "                  groups=groups,\n",
    "                  width_per_group=width_per_group)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ffad793",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "using cuda:0 device.\n",
      "Using 4 dataloader workers every process\n",
      "using 20000 images for training, 2000 images for validation.\n",
      "  0%|                                                                                         | 0/5000 [00:00<?, ?it/s]"
     ]
    }
   ],
   "source": [
    "\n",
    "def main():\n",
    "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "    print(\"using {} device.\".format(device))\n",
    "\n",
    "    data_transform = {\n",
    "        \"train\": transforms.Compose([transforms.RandomResizedCrop(224),\n",
    "                                     transforms.RandomHorizontalFlip(),\n",
    "                                     transforms.ToTensor(),\n",
    "                                     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),\n",
    "        \"val\": transforms.Compose([transforms.Resize(256),\n",
    "                                   transforms.CenterCrop(224),\n",
    "                                   transforms.ToTensor(),\n",
    "                                   transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}\n",
    "\n",
    "    data_root = os.path.abspath(os.path.join(os.getcwd(), \"../..\"))  # get data root path\n",
    "    image_path = os.path.join(data_root,\"data_set\" , \"cat_dog\")  # flower data set path\n",
    "    assert os.path.exists(image_path), \"{} path does not exist.\".format(image_path)\n",
    "    train_dataset = datasets.ImageFolder(root=os.path.join(image_path, \"train\"),\n",
    "                                         transform=data_transform[\"train\"])\n",
    "    train_num = len(train_dataset)\n",
    "\n",
    "    # {'cat':0,'dog':1}\n",
    "    flower_list = train_dataset.class_to_idx\n",
    "    cla_dict = dict((val, key) for key, val in flower_list.items())\n",
    "    # write dict into json file\n",
    "    json_str = json.dumps(cla_dict, indent=4)\n",
    "    with open('class_indices.json', 'w') as json_file:\n",
    "        json_file.write(json_str)\n",
    "\n",
    "    batch_size = 4\n",
    "    nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers\n",
    "    print('Using {} dataloader workers every process'.format(nw))\n",
    "\n",
    "    train_loader = torch.utils.data.DataLoader(train_dataset,\n",
    "                                               batch_size=batch_size, shuffle=True,\n",
    "                                               num_workers=nw)\n",
    "\n",
    "    validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, \"val\"),\n",
    "                                            transform=data_transform[\"val\"])\n",
    "    val_num = len(validate_dataset)\n",
    "    validate_loader = torch.utils.data.DataLoader(validate_dataset,\n",
    "                                                  batch_size=batch_size, shuffle=False,\n",
    "                                                  num_workers=nw)\n",
    "\n",
    "    print(\"using {} images for training, {} images for validation.\".format(train_num,\n",
    "                                                                           val_num))\n",
    "    \n",
    "    net = resnet34()\n",
    "    # load pretrain weights\n",
    "    # download url: https://download.pytorch.org/models/resnet34-333f7ec4.pth\n",
    "    model_weight_path = \"./resnet34-pre.pth\"\n",
    "    assert os.path.exists(model_weight_path), \"file {} does not exist.\".format(model_weight_path)\n",
    "    net.load_state_dict(torch.load(model_weight_path, map_location='cpu'))\n",
    "    # for param in net.parameters():\n",
    "    #     param.requires_grad = False\n",
    "\n",
    "    # change fc layer structure\n",
    "    in_channel = net.fc.in_features\n",
    "    net.fc = nn.Linear(in_channel, 2)\n",
    "    net.to(device)\n",
    "\n",
    "    # define loss function\n",
    "    loss_function = nn.CrossEntropyLoss()\n",
    "\n",
    "    # construct an optimizer\n",
    "    params = [p for p in net.parameters() if p.requires_grad]\n",
    "    optimizer = optim.Adam(params, lr=0.0001)\n",
    "\n",
    "    epochs = 3\n",
    "    best_acc = 0.0\n",
    "    save_path = './resNet34_catdog.pth'\n",
    "    train_steps = len(train_loader)\n",
    "    for epoch in range(epochs):\n",
    "        # train\n",
    "        net.train()\n",
    "        running_loss = 0.0\n",
    "        train_bar = tqdm(train_loader, file=sys.stdout)\n",
    "        for step, data in enumerate(train_bar):\n",
    "            images, labels = data\n",
    "            optimizer.zero_grad()\n",
    "            logits = net(images.to(device))\n",
    "            loss = loss_function(logits, labels.to(device))\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            # print statistics\n",
    "            running_loss += loss.item()\n",
    "\n",
    "            train_bar.desc = \"train epoch[{}/{}] loss:{:.3f}\".format(epoch + 1,\n",
    "                                                                     epochs,\n",
    "                                                                     loss)\n",
    "\n",
    "        # validate\n",
    "        net.eval()\n",
    "        acc = 0.0  # accumulate accurate number / epoch\n",
    "        with torch.no_grad():\n",
    "            val_bar = tqdm(validate_loader, file=sys.stdout)\n",
    "            for val_data in val_bar:\n",
    "                val_images, val_labels = val_data\n",
    "                outputs = net(val_images.to(device))\n",
    "                # loss = loss_function(outputs, test_labels)\n",
    "                predict_y = torch.max(outputs, dim=1)[1]\n",
    "                acc += torch.eq(predict_y, val_labels.to(device)).sum().item()\n",
    "\n",
    "                val_bar.desc = \"valid epoch[{}/{}]\".format(epoch + 1,\n",
    "                                                           epochs)\n",
    "\n",
    "        val_accurate = acc / val_num\n",
    "        print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %\n",
    "              (epoch + 1, running_loss / train_steps, val_accurate))\n",
    "\n",
    "        if val_accurate > best_acc:\n",
    "            best_acc = val_accurate\n",
    "            torch.save(net.state_dict(), save_path)\n",
    "\n",
    "    print('Finished Training')\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf1aae4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1784ef01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "class: daisy        prob: 0.00127\n",
      "class: dandelion    prob: 0.00017\n",
      "class: roses        prob: 0.678\n",
      "class: sunflowers   prob: 0.000113\n",
      "class: tulips       prob: 0.32\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def main():\n",
    "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "    data_transform = transforms.Compose(\n",
    "        [transforms.Resize(256),\n",
    "         transforms.CenterCrop(224),\n",
    "         transforms.ToTensor(),\n",
    "         transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])\n",
    "\n",
    "    # load image\n",
    "    img_path = \"./tulip.jpg\"\n",
    "    assert os.path.exists(img_path), \"file: '{}' dose not exist.\".format(img_path)\n",
    "    img = Image.open(img_path)\n",
    "    plt.imshow(img)\n",
    "    # [N, C, H, W]\n",
    "    img = data_transform(img)\n",
    "    # expand batch dimension\n",
    "    img = torch.unsqueeze(img, dim=0)\n",
    "\n",
    "    # read class_indict\n",
    "    json_path = './class_indices.json'\n",
    "    assert os.path.exists(json_path), \"file: '{}' dose not exist.\".format(json_path)\n",
    "\n",
    "    with open(json_path, \"r\") as f:\n",
    "        class_indict = json.load(f)\n",
    "\n",
    "    # create model\n",
    "    model = resnet34(num_classes=5).to(device)\n",
    "\n",
    "    # load model weights\n",
    "    weights_path = \"./resNet34.pth\"\n",
    "    assert os.path.exists(weights_path), \"file: '{}' dose not exist.\".format(weights_path)\n",
    "    model.load_state_dict(torch.load(weights_path, map_location=device))\n",
    "\n",
    "    # prediction\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        # predict class\n",
    "        output = torch.squeeze(model(img.to(device))).cpu()\n",
    "        predict = torch.softmax(output, dim=0)\n",
    "        predict_cla = torch.argmax(predict).numpy()\n",
    "\n",
    "    print_res = \"class: {}   prob: {:.3}\".format(class_indict[str(predict_cla)],\n",
    "                                                 predict[predict_cla].numpy())\n",
    "    plt.title(print_res)\n",
    "    for i in range(len(predict)):\n",
    "        print(\"class: {:10}   prob: {:.3}\".format(class_indict[str(i)],\n",
    "                                                  predict[i].numpy()))\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fe7f1036",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "image: ./data_set/flower_data/val/tulips\\10094731133_94a942463c.jpg  class: tulips  prob: 0.854\n",
      "image: ./data_set/flower_data/val/tulips\\10995953955_089572caf0.jpg  class: tulips  prob: 0.915\n",
      "image: ./data_set/flower_data/val/tulips\\112650879_82adc2cc04_n.jpg  class: tulips  prob: 0.999\n",
      "image: ./data_set/flower_data/val/tulips\\113902743_8f537f769b_n.jpg  class: tulips  prob: 0.615\n",
      "image: ./data_set/flower_data/val/tulips\\11614202956_1dcf1c96a1.jpg  class: roses  prob: 0.967\n",
      "image: ./data_set/flower_data/val/tulips\\12557176134_ecbf15885b.jpg  class: tulips  prob: 0.711\n",
      "image: ./data_set/flower_data/val/tulips\\12883412424_cb5086b43f_n.jpg  class: tulips  prob: 0.956\n",
      "image: ./data_set/flower_data/val/tulips\\12916017805_1cde91a891_n.jpg  class: tulips  prob: 0.992\n",
      "image: ./data_set/flower_data/val/tulips\\12916135413_dafcf3089e_n.jpg  class: tulips  prob: 0.998\n",
      "image: ./data_set/flower_data/val/tulips\\1353748522_b9c630b162.jpg  class: tulips  prob: 1.0\n",
      "image: ./data_set/flower_data/val/tulips\\135994133_4f306fe4bf_n.jpg  class: tulips  prob: 0.998\n",
      "image: ./data_set/flower_data/val/tulips\\13903937027_44b9f2f5b8.jpg  class: tulips  prob: 0.846\n",
      "image: ./data_set/flower_data/val/tulips\\13903988248_22da33f341.jpg  class: tulips  prob: 0.828\n",
      "image: ./data_set/flower_data/val/tulips\\13953090784_0c7d7a904e.jpg  class: tulips  prob: 0.98\n",
      "image: ./data_set/flower_data/val/tulips\\13954659583_03981dea99_n.jpg  class: tulips  prob: 0.998\n",
      "image: ./data_set/flower_data/val/tulips\\13976191172_6f23a0b313.jpg  class: tulips  prob: 0.999\n",
      "image: ./data_set/flower_data/val/tulips\\14024864234_713158c27f_n.jpg  class: tulips  prob: 0.985\n",
      "image: ./data_set/flower_data/val/tulips\\14046760909_0c73e84a1f_n.jpg  class: tulips  prob: 0.926\n",
      "image: ./data_set/flower_data/val/tulips\\14068200854_5c13668df9_m.jpg  class: tulips  prob: 1.0\n",
      "image: ./data_set/flower_data/val/tulips\\14071516088_b526946e17_n.jpg  class: tulips  prob: 0.997\n",
      "image: ./data_set/flower_data/val/tulips\\14087425312_2b5846b570_n.jpg  class: tulips  prob: 0.984\n",
      "image: ./data_set/flower_data/val/tulips\\14097366955_84ef6369f2.jpg  class: tulips  prob: 0.999\n",
      "image: ./data_set/flower_data/val/tulips\\14103897845_7986002615.jpg  class: tulips  prob: 0.86\n",
      "image: ./data_set/flower_data/val/tulips\\14149603605_eedfe9678c_n.jpg  class: tulips  prob: 0.94\n",
      "image: ./data_set/flower_data/val/tulips\\14255917256_84c23c572b.jpg  class: tulips  prob: 0.79\n",
      "image: ./data_set/flower_data/val/tulips\\14487712670_aebe715525_m.jpg  class: tulips  prob: 0.77\n",
      "image: ./data_set/flower_data/val/tulips\\14487943607_651e8062a1_m.jpg  class: tulips  prob: 0.649\n",
      "image: ./data_set/flower_data/val/tulips\\14674071872_2df55466d5_m.jpg  class: tulips  prob: 0.99\n",
      "image: ./data_set/flower_data/val/tulips\\16283125269_4cfae953f1.jpg  class: tulips  prob: 0.999\n",
      "image: ./data_set/flower_data/val/tulips\\164578909_51f245d3fa_n.jpg  class: roses  prob: 0.708\n",
      "image: ./data_set/flower_data/val/tulips\\16680927427_07ca6e4552_n.jpg  class: tulips  prob: 0.999\n",
      "image: ./data_set/flower_data/val/tulips\\16680930777_7e7f292fc5_n.jpg  class: dandelion  prob: 0.573\n",
      "image: ./data_set/flower_data/val/tulips\\16702188449_3dacce90b2_m.jpg  class: tulips  prob: 0.58\n",
      "image: ./data_set/flower_data/val/tulips\\16751015081_af2ef77c9a_n.jpg  class: tulips  prob: 0.99\n",
      "image: ./data_set/flower_data/val/tulips\\16765283686_0315ae00a8.jpg  class: tulips  prob: 0.651\n",
      "image: ./data_set/flower_data/val/tulips\\16986144192_55e0e6c152.jpg  class: tulips  prob: 0.998\n",
      "image: ./data_set/flower_data/val/tulips\\17167151059_a53bfe0b02.jpg  class: tulips  prob: 0.637\n",
      "image: ./data_set/flower_data/val/tulips\\17408197905_829c4d7940_m.jpg  class: tulips  prob: 0.928\n",
      "image: ./data_set/flower_data/val/tulips\\2087981909_fd468de5c4_n.jpg  class: tulips  prob: 0.991\n",
      "image: ./data_set/flower_data/val/tulips\\2232289392_9a79a0c5cb_n.jpg  class: tulips  prob: 0.997\n",
      "image: ./data_set/flower_data/val/tulips\\2238626027_058c404b94.jpg  class: tulips  prob: 0.999\n",
      "image: ./data_set/flower_data/val/tulips\\2294116183_a30d2aa2c1_m.jpg  class: tulips  prob: 0.982\n",
      "image: ./data_set/flower_data/val/tulips\\2434178332_7fcf85aa95_n.jpg  class: tulips  prob: 0.982\n",
      "image: ./data_set/flower_data/val/tulips\\2436998042_4906ea07af.jpg  class: tulips  prob: 0.982\n",
      "image: ./data_set/flower_data/val/tulips\\2481827798_6087d71134.jpg  class: tulips  prob: 0.736\n",
      "image: ./data_set/flower_data/val/tulips\\251811158_75fa3034ff.jpg  class: tulips  prob: 0.97\n",
      "image: ./data_set/flower_data/val/tulips\\3421027755_cdb8fef8e8_n.jpg  class: tulips  prob: 0.978\n",
      "image: ./data_set/flower_data/val/tulips\\38287568_627de6ca20.jpg  class: tulips  prob: 0.994\n",
      "image: ./data_set/flower_data/val/tulips\\434146736_310a42d9cb_m.jpg  class: tulips  prob: 0.998\n",
      "image: ./data_set/flower_data/val/tulips\\4442928974_9672d630b2_n.jpg  class: tulips  prob: 0.967\n",
      "image: ./data_set/flower_data/val/tulips\\4550117239_5907aaba4c.jpg  class: tulips  prob: 0.981\n",
      "image: ./data_set/flower_data/val/tulips\\4582198748_20fa7caaa1.jpg  class: tulips  prob: 0.987\n",
      "image: ./data_set/flower_data/val/tulips\\486896118_bcc7b8e1d6.jpg  class: tulips  prob: 0.866\n",
      "image: ./data_set/flower_data/val/tulips\\5012813078_99fb977616_n.jpg  class: tulips  prob: 0.995\n",
      "image: ./data_set/flower_data/val/tulips\\5430796647_f21b7b0fea.jpg  class: tulips  prob: 0.952\n",
      "image: ./data_set/flower_data/val/tulips\\5653364300_bc557236c7_n.jpg  class: tulips  prob: 0.999\n",
      "image: ./data_set/flower_data/val/tulips\\5674167473_ac696c8989_n.jpg  class: tulips  prob: 0.984\n",
      "image: ./data_set/flower_data/val/tulips\\5738195260_b3fc107aa7_n.jpg  class: tulips  prob: 0.996\n",
      "image: ./data_set/flower_data/val/tulips\\6903831250_a2757fff82_m.jpg  class: tulips  prob: 0.51\n",
      "image: ./data_set/flower_data/val/tulips\\6931708704_fccb06fea8.jpg  class: tulips  prob: 0.999\n",
      "image: ./data_set/flower_data/val/tulips\\6958342976_a4a9483488_n.jpg  class: tulips  prob: 0.495\n",
      "image: ./data_set/flower_data/val/tulips\\7002703410_3e97b29da5_n.jpg  class: tulips  prob: 0.999\n",
      "image: ./data_set/flower_data/val/tulips\\7094271655_79a6f972c1_n.jpg  class: tulips  prob: 0.931\n",
      "image: ./data_set/flower_data/val/tulips\\7145978709_2d1596f462.jpg  class: roses  prob: 0.898\n",
      "image: ./data_set/flower_data/val/tulips\\7166539842_43b7e02883.jpg  class: tulips  prob: 0.998\n",
      "image: ./data_set/flower_data/val/tulips\\7166564830_8b34a3fd35_n.jpg  class: tulips  prob: 1.0\n",
      "image: ./data_set/flower_data/val/tulips\\7166570828_7c26ca5766_n.jpg  class: tulips  prob: 0.805\n",
      "image: ./data_set/flower_data/val/tulips\\7166618384_850905fc63_n.jpg  class: tulips  prob: 0.527\n",
      "image: ./data_set/flower_data/val/tulips\\7166635566_ee240b5408_n.jpg  class: tulips  prob: 0.997\n",
      "image: ./data_set/flower_data/val/tulips\\8394186551_28eed83a94_m.jpg  class: tulips  prob: 0.997\n",
      "image: ./data_set/flower_data/val/tulips\\8520488975_a50d377f91.jpg  class: tulips  prob: 0.909\n",
      "image: ./data_set/flower_data/val/tulips\\8603340662_0779bd87fd.jpg  class: tulips  prob: 0.994\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import json\n",
    "\n",
    "import torch\n",
    "from PIL import Image\n",
    "from torchvision import transforms\n",
    "\n",
    "\n",
    "def main():\n",
    "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "    data_transform = transforms.Compose(\n",
    "        [transforms.Resize(256),\n",
    "         transforms.CenterCrop(224),\n",
    "         transforms.ToTensor(),\n",
    "         transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])\n",
    "\n",
    "    # load image\n",
    "    # 指向需要遍历预测的图像文件夹\n",
    "    imgs_root = \"./data_set/flower_data/val/tulips\"\n",
    "    assert os.path.exists(imgs_root), f\"file: '{imgs_root}' dose not exist.\"\n",
    "    # 读取指定文件夹下所有jpg图像路径\n",
    "    img_path_list = [os.path.join(imgs_root, i) for i in os.listdir(imgs_root) if i.endswith(\".jpg\")]\n",
    "\n",
    "    # read class_indict\n",
    "    json_path = './class_indices.json'\n",
    "    assert os.path.exists(json_path), f\"file: '{json_path}' dose not exist.\"\n",
    "\n",
    "    json_file = open(json_path, \"r\")\n",
    "    class_indict = json.load(json_file)\n",
    "\n",
    "    # create model\n",
    "    model = resnet34(num_classes=5).to(device)\n",
    "\n",
    "    # load model weights\n",
    "    weights_path = \"./resNet34.pth\"\n",
    "    assert os.path.exists(weights_path), f\"file: '{weights_path}' dose not exist.\"\n",
    "    model.load_state_dict(torch.load(weights_path, map_location=device))\n",
    "\n",
    "    # prediction\n",
    "    model.eval()\n",
    "    batch_size = 8  # 每次预测时将多少张图片打包成一个batch\n",
    "    with torch.no_grad():\n",
    "        for ids in range(0, len(img_path_list) // batch_size):\n",
    "            img_list = []\n",
    "            for img_path in img_path_list[ids * batch_size: (ids + 1) * batch_size]:\n",
    "                assert os.path.exists(img_path), f\"file: '{img_path}' dose not exist.\"\n",
    "                img = Image.open(img_path)\n",
    "                img = data_transform(img)\n",
    "                img_list.append(img)\n",
    "\n",
    "            # batch img\n",
    "            # 将img_list列表中的所有图像打包成一个batch\n",
    "            batch_img = torch.stack(img_list, dim=0)\n",
    "            # predict class\n",
    "            output = model(batch_img.to(device)).cpu()\n",
    "            predict = torch.softmax(output, dim=1)\n",
    "            probs, classes = torch.max(predict, dim=1)\n",
    "\n",
    "            for idx, (pro, cla) in enumerate(zip(probs, classes)):\n",
    "                print(\"image: {}  class: {}  prob: {:.3}\".format(img_path_list[ids * batch_size + idx],\n",
    "                                                                 class_indict[str(cla.numpy())],\n",
    "                                                                 pro.numpy()))\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b721992",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch",
   "language": "python",
   "name": "torch"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
